home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / utils / gdb36p4s.zoo / valprint.c < prev    next >
C/C++ Source or Header  |  1993-08-13  |  41KB  |  1,498 lines
  1. /* Print values for GNU debugger gdb.
  2.    Copyright (C) 1986, 1988, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. GDB is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GDB is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GDB; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include <stdio.h>
  21. #include "defs.h"
  22. #include "param.h"
  23. #include "symtab.h"
  24. #include "value.h"
  25.  
  26. /* GNU software is only expected to run on systems with 32-bit integers.  */
  27. #define UINT_MAX 0xffffffff
  28.  
  29. /* Maximum number of chars to print for a string pointer value
  30.    or vector contents, or UINT_MAX for no limit.  */
  31.  
  32. static unsigned int print_max;
  33.  
  34. static void type_print_varspec_suffix ();
  35. static void type_print_varspec_prefix ();
  36. static void type_print_base ();
  37. static void type_print_method_args ();
  38.  
  39.  
  40. char **unsigned_type_table;
  41. char **signed_type_table;
  42. char **float_type_table;
  43.  
  44.  
  45. /* Print repeat counts if there are more than this
  46.    many repetitions of an element in an array.  */
  47. #define    REPEAT_COUNT_THRESHOLD    10
  48.  
  49. /* Print the character string STRING, printing at most LENGTH characters.
  50.    Printing stops early if the number hits print_max; repeat counts
  51.    are printed as appropriate.  Print ellipses at the end if we
  52.    had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.  */
  53.  
  54. void
  55. print_string (stream, string, length, force_ellipses)
  56.      FILE *stream;
  57.      char *string;
  58.      unsigned int length;
  59.      int force_ellipses;
  60. {
  61.   register unsigned int i;
  62.   unsigned int things_printed = 0;
  63.   int in_quotes = 0;
  64.   int need_comma = 0;
  65.  
  66.   if (length == 0)
  67.     {
  68.       fputs_filtered ("\"\"", stdout);
  69.       return;
  70.     }
  71.  
  72.   for (i = 0; i < length && things_printed < print_max; ++i)
  73.     {
  74.       /* Position of the character we are examining
  75.      to see whether it is repeated.  */
  76.       unsigned int rep1;
  77.       /* Number of repititions we have detected so far.  */
  78.       unsigned int reps;
  79.  
  80.       QUIT;
  81.  
  82.       if (need_comma)
  83.     {
  84.       fputs_filtered (", ", stream);
  85.       need_comma = 0;
  86.     }
  87.  
  88.       rep1 = i + 1;
  89.       reps = 1;
  90.       while (rep1 < length && string[rep1] == string[i])
  91.     {
  92.       ++rep1;
  93.       ++reps;
  94.     }
  95.  
  96.       if (reps > REPEAT_COUNT_THRESHOLD)
  97.     {
  98.       if (in_quotes)
  99.         {
  100.           fputs_filtered ("\", ", stream);
  101.           in_quotes = 0;
  102.         }
  103.       fputs_filtered ("'", stream);
  104.       printchar (string[i], stream, '\'');
  105.       fprintf_filtered (stream, "' <repeats %u times>", reps);
  106.       i = rep1 - 1;
  107.       things_printed += REPEAT_COUNT_THRESHOLD;
  108.       need_comma = 1;
  109.     }
  110.       else
  111.     {
  112.       if (!in_quotes)
  113.         {
  114.           fputs_filtered ("\"", stream);
  115.           in_quotes = 1;
  116.         }
  117.       printchar (string[i], stream, '"');
  118.       ++things_printed;
  119.     }
  120.     }
  121.  
  122.   /* Terminate the quotes if necessary.  */
  123.   if (in_quotes)
  124.     fputs_filtered ("\"", stream);
  125.  
  126.   if (force_ellipses || i < length)
  127.     fputs_filtered ("...", stream);
  128. }
  129.  
  130. /* Print the value VAL in C-ish syntax on stream STREAM.
  131.    FORMAT is a format-letter, or 0 for print in natural format of data type.
  132.    If the object printed is a string pointer, returns
  133.    the number of string bytes printed.  */
  134.  
  135. int
  136. value_print (val, stream, format, pretty)
  137.      value val;
  138.      FILE *stream;
  139.      char format;
  140.      enum val_prettyprint pretty;
  141. {
  142.   register unsigned int i, n, typelen;
  143.  
  144.   /* A "repeated" value really contains several values in a row.
  145.      They are made by the @ operator.
  146.      Print such values as if they were arrays.  */
  147.  
  148.   if (VALUE_REPEATED (val))
  149.     {
  150.       n = VALUE_REPETITIONS (val);
  151.       typelen = TYPE_LENGTH (VALUE_TYPE (val));
  152.       fprintf_filtered (stream, "{");
  153.       /* Print arrays of characters using string syntax.  */
  154.       if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT
  155.       && format == 0)
  156.     print_string (stream, VALUE_CONTENTS (val), n, 0);
  157.       else
  158.     {
  159.       unsigned int things_printed = 0;
  160.       
  161.       for (i = 0; i < n && things_printed < print_max; i++)
  162.         {
  163.           /* Position of the array element we are examining to see
  164.          whether it is repeated.  */
  165.           unsigned int rep1;
  166.           /* Number of repititions we have detected so far.  */
  167.           unsigned int reps;
  168.  
  169.           if (i != 0)
  170.         fprintf_filtered (stream, ", ");
  171.  
  172.           rep1 = i + 1;
  173.           reps = 1;
  174.           while (rep1 < n
  175.              && !bcmp (VALUE_CONTENTS (val) + typelen * i,
  176.                    VALUE_CONTENTS (val) + typelen * rep1, typelen))
  177.         {
  178.           ++reps;
  179.           ++rep1;
  180.         }
  181.  
  182.           if (reps > REPEAT_COUNT_THRESHOLD)
  183.         {
  184.           val_print (VALUE_TYPE (val),
  185.                  VALUE_CONTENTS (val) + typelen * i,
  186.                  VALUE_ADDRESS (val) + typelen * i,
  187.                  stream, format, 1, 0, pretty);
  188.           fprintf (stream, " <repeats %u times>", reps);
  189.           i = rep1 - 1;
  190.           things_printed += REPEAT_COUNT_THRESHOLD;
  191.         }
  192.           else
  193.         {
  194.           val_print (VALUE_TYPE (val),
  195.                  VALUE_CONTENTS (val) + typelen * i,
  196.                  VALUE_ADDRESS (val) + typelen * i,
  197.                  stream, format, 1, 0, pretty);
  198.           things_printed++;
  199.         }
  200.         }
  201.       if (i < n)
  202.         fprintf_filtered (stream, "...");
  203.     }
  204.       fprintf_filtered (stream, "}");
  205.       return n * typelen;
  206.     }
  207.   else
  208.     {
  209.       /* If it is a pointer, indicate what it points to.
  210.  
  211.      Print type also if it is a reference.
  212.  
  213.          C++: if it is a member pointer, we will take care
  214.      of that when we print it.  */
  215.       if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR
  216.       || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
  217.     {
  218.       fprintf_filtered (stream, "(");
  219.       type_print (VALUE_TYPE (val), "", stream, -1);
  220.       fprintf_filtered (stream, ") ");
  221.  
  222.       /* If this is a function pointer, try to print what
  223.          function it is pointing to by name.  */
  224.       if (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (val)))
  225.           == TYPE_CODE_FUNC)
  226.         {
  227.           print_address (((int *) VALUE_CONTENTS (val))[0], stream);
  228.           /* Return value is irrelevant except for string pointers.  */
  229.           return 0;
  230.         }
  231.     }
  232.       return val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
  233.             VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
  234.     }
  235. }
  236.  
  237. /* Return truth value for assertion that TYPE is of the type
  238.    "pointer to virtual function".  */
  239. static int
  240. is_vtbl_ptr_type(type)
  241.      struct type *type;
  242. {
  243.   return (!strcmp(TYPE_NAME(type), "$vtbl_ptr_type"));
  244. }
  245.  
  246. /* Return truth value for the assertion that TYPE is of the type
  247.    "pointer to virtual function table".  */
  248. static int
  249. is_vtbl_member(type)
  250.      struct type *type;
  251. {
  252.   if (TYPE_CODE (type) == TYPE_CODE_PTR
  253.       && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY
  254.       && TYPE_CODE (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type))) == TYPE_CODE_STRUCT)
  255.     /* Virtual functions tables are full of pointers to virtual functions.  */
  256.     return is_vtbl_ptr_type (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)));
  257.   return 0;
  258. }
  259.  
  260. static int prettyprint;    /* Controls prettyprinting of structures.  */
  261. int unionprint;        /* Controls printing of nested unions.  */
  262. int vtblprint;        /* Controls printing of vtbl's */
  263.  
  264. /* Print data of type TYPE located at VALADDR (within GDB),
  265.    which came from the inferior at address ADDRESS,
  266.    onto stdio stream STREAM according to FORMAT
  267.    (a letter or 0 for natural format).
  268.  
  269.    If the data are a string pointer, returns the number of
  270.    sting characters printed.
  271.  
  272.    if DEREF_REF is nonzero, then dereference references,
  273.    otherwise just print them like pointers.
  274.  
  275.    The PRETTY parameter controls prettyprinting.  */
  276.  
  277. int
  278. val_print (type, valaddr, address, stream, format,
  279.        deref_ref, recurse, pretty)
  280.      struct type *type;
  281.      char *valaddr;
  282.      CORE_ADDR address;
  283.      FILE *stream;
  284.      char format;
  285.      int deref_ref;
  286.      int recurse;
  287.      enum val_prettyprint pretty;
  288. {
  289.   register unsigned int i;
  290.   int len, n_baseclasses;
  291.   struct type *elttype;
  292.   int eltlen;
  293.   LONGEST val;
  294.   unsigned char c;
  295.  
  296.   if (pretty == Val_pretty_default)
  297.